﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//class Time
//{
//public:
//	Time(int hour = 0)
//		:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	int _hour;
//};
//
//class Date
//{
//public:
//	//初始化列表中每个成员只能出现一次
//	//成员定义
//	Date(int& xx, int year, int month, int day)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//		,_n(1)//const修饰的变量和引用必须在初始化列表中初始化
//		,_ref(xx)
//		,_t(1)//没有默认构造的自定义类型必须在初始化列表中初始化
//		,_ptr((int*)malloc(12))
//		//初始化列表可以和函数体初始化混合使用
//	{
//		if (_ptr == nullptr)
//		{
//			perror("malloc fail");
//		}
//		else
//		{
//			memset(_ptr, 0, 12);
//		}
//	}
//
//	void Print()
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//private:
//	//成员声明
//	/*int _year;
//	int _month;
//	int _day;*/
//
//	//↓在声明的时候给缺省值,(虽然看着像定义,但其实是声明)
//	//缺省值是给初始化列表用的,先用传递过来的,再用构造函数的缺省值,最后用成员声明的缺省值
//	//但是实际上不能代替默认构造,虽然有缺省值
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//	//↓必须在初始化列表中初始化
//	const int _n;//const必须也只能在定义的地方初始化,而且只有一次初始化机会
//	int& _ref;//引用也只能在定义的地方初始化,而且只有一次初始化机会
//	Time _t;//如果在Date不初始化Time,则调用Time的默认构造
//	int* _ptr;
//};
//int main()
//{
//	int x = 0;
//	//对象定义
//	Date d1(x, 2025, 9, 3);
//	//Date d2(x);
//	d1.Print();
//	//d2.Print();
//	return 0;
//}


//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		,_month(month)
//      ,_day(day)
//	{}
//
//	void Print()
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//private:
//	//但是实际上不能代替默认构造,虽然有缺省值
//
//	//主要用于内置类型确定性初始化↓
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//	//给没有显⽰在初始化列表初始化的成员使⽤的↓
//	int* _ptr = (int*)malloc(12);
//	Time _t = 1;
//};
//
//int main()
//{
//	//Date d1;
//	//d1.Print();
//	//不通过,显示没有默认构造
//
//
//	return 0;
//}


//class Time
//{
//public:
//	Time(int hour = 0)
//		:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	int _hour;
//};
//
//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//	{}
//
//	void Print()
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//private:
//	//但是实际上不能代替默认构造,虽然有缺省值
//
//	//C++11增加的这个缺省值,仅仅是针对初始化列表中并没有构造的变量,进行初始化
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//	//给没有显⽰在初始化列表初始化的成员使⽤的↓
//	int* _ptr = (int*)malloc(12);
//	Time _t = 1;
//};
//
//int main()
//{
//
//	Date d2(2025, 9, 3);
//	d2.Print();
//
//	//cout << d2._t._hour << endl;//1
//
//	return 0;
//}


//class Time
//{
//public:
//	Time(int hour = 0)
//		:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	int _hour;
//};
//
////每个构造函数都有初始化列表
//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//	{
//		_year = 12;//函数体内可重复
//	}
//
//	void Print()
//	{
//		cout << _year << "年" << _month << "月" << _day << "日" << endl;
//	}
//
//private:
//	//但是实际上不能代替默认构造,虽然有缺省值
//
//	//C++11增加的这个缺省值,仅仅是针对初始化列表中并没有构造的变量,进行初始化
//	//按照声明的顺序进行初始化列表中的初始化!!!
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//	//给没有显⽰在初始化列表初始化的成员使⽤的↓
//	int* _ptr = (int*)malloc(12);
//	Time _t = 1;
//	const int _n = 1;
//	//可以看成将初始化列表中没有的成员变量变形过去
//	//,int* _ptr((int*)malloc(12));
//	//,Time _t(1);
//	//,const int _n(1);
//	//一样的效果
//};
//
////每个成员都要走初始化列表
////1.在初始化列表初始化的成员
////2.没有在初始化列表的成员
////	a.声明的地方有缺省值用缺省值
////	b.没有缺省值
////		x.内置类型,不确定,看编译器,大概率是随机值
////		y.自定义类型,调用默认构造,没有默认构造就报错
////3.引用,const,没有默认构造的自定义类型 必须在初始化列表初始化或者声明缺省值
//
//int main()
//{
//
//	Date d2(2025, 9, 3);
//	d2.Print();
//
//	//cout << d2._t._hour << endl;//1
//	//cout << d2._n << endl;//1
//
//	return 0;
//}



class A
{
public:
	A()//构造函数一次,静态变量就+1
	{
		++_scount;
	}
	A(const A& t)//拷贝构造一次,静态变量就+1
	{
		++_scount;
	}
	~A()//析构一次,静态变量就-1
	{
		--_scount;
	}
	//静态成员函数没有this指针,内部可以访问其他的静态成员,但是不能访问非静态成员
	static int GetACount()
	{
		return _scount;
	}

	void func()
	{
		cout << _scount << endl;
		cout << GetACount() << endl;
	}
private:
	// 类⾥⾯声明 
	static int _scount;
	//生命周期是全局的,但只能在类里面使用或者公有情况下在类外用访问修饰限定符
	int n;
};
// 类外⾯初始化 
int A::_scount = 0;
// 静态成员变量存放在静态区
int main()
{
	//类名::静态成员 或者 对象.静态成员 均可
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
	cout << a1.GetACount() << endl;
	// 编译报错：error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明) 
	//cout << A::_scount << endl;
	return 0;
}

//全局变量在main函数之前就初始化
//局部的静态变量在程序走到这一行才初始化

//析构时先析构局部,再析构全局